545C - Woodcutters - CodeForces Solution

from __future__ import division, print_function
import os,sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip




from math import ceil, floor, factorial
from bisect import bisect_left, bisect_right
from collections import defaultdict




abc='abcdefghijklmnopqrstuvwxyz'
abd={'a':0,'b':1,'c':2,'d':3,'e':4,'f':5,'g':6,'h':7,'i':8,'j':9,'k':10,'l':11,'m':12,'n':13,'o':14,'p':15,'q':16,'r':17,'s':18,'t':19,'u':20,'v':21,'w':22,'x':23,'y':24,'z':25}


M=1000000007
INF = float("inf")
PI = 3.141592653589793

def copy2d(lst): return [x[:] for x in lst]   def isPowerOfTwo(x): return (x and (not(x & (x - 1))) )

LB = bisect_left   UB = bisect_right   
def BS(a, x):          i = bisect_left(a, x)
    if i != len(a) and a[i] == x:
        return i
    else:
        return -1

def gcd(x, y):
    while y:
        x, y = y, x % y
    return x

def lcm(x, y):
    return (x*y)//gcd(x,y)

    



def main():
    TestCases = 1
    
    for _ in range(TestCases):
        n = int(input())
                        
        X,H=[],[]
        for _ in range(n):
            x,h = [int(i) for i in input().split()]
            X.append(x)
            H.append(h)
        
        if n<=2:
            print(n)
            continue
        ans = 2
        isempty = [True]*(n-1)
        both=[]
        for i in range(1,n-1):
            h = H[i]
            left = X[i] - X[i-1]
            right = X[i+1] - X[i]

            can_fall_left = left>h and (True if isempty[i-1] else left > h+H[i-1])
            can_fall_right = right>h and (True if isempty[i] else right > h+H[i+1])

            if can_fall_left and can_fall_right:
                                both.append(i)
                continue
            
            elif can_fall_left:
                                isempty[i-1] = False
                ans+=1
                
            elif can_fall_right:
                                isempty[i] = False
                ans+=1
                

        for i in both:
            h = H[i]
            left = X[i] - X[i-1]
            right = X[i+1] - X[i]

            can_fall_left = left>h and (True if isempty[i-1] else left > h+H[i-1])
            can_fall_right = right>h and (True if isempty[i] else right > h+H[i+1])

            if can_fall_left:
                isempty[i-1] = False
                ans+=1
            elif can_fall_right:
                isempty[i] = False
                ans+=1
            

                        print(ans)
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
if not os.path.isdir('C:/users/acer'):
    BUFSIZE = 8192
    
    
    class FastIO(IOBase):
        newlines = 0
    
        def __init__(self, file):
            self._fd = file.fileno()
            self.buffer = BytesIO()
            self.writable = "x" in file.mode or "r" not in file.mode
            self.write = self.buffer.write if self.writable else None
    
        def read(self):
            while True:
                b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
                if not b:
                    break
                ptr = self.buffer.tell()
                self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
            self.newlines = 0
            return self.buffer.read()
    
        def readline(self):
            while self.newlines == 0:
                b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
                self.newlines = b.count(b"\n") + (not b)
                ptr = self.buffer.tell()
                self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
            self.newlines -= 1
            return self.buffer.readline()
    
        def flush(self):
            if self.writable:
                os.write(self._fd, self.buffer.getvalue())
                self.buffer.truncate(0), self.buffer.seek(0)
    
    
    class IOWrapper(IOBase):
        def __init__(self, file):
            self.buffer = FastIO(file)
            self.flush = self.buffer.flush
            self.writable = self.buffer.writable
            self.write = lambda s: self.buffer.write(s.encode("ascii"))
            self.read = lambda: self.buffer.read().decode("ascii")
            self.readline = lambda: self.buffer.readline().decode("ascii")
    
    
    def print(*args, **kwargs):
        
        sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
        at_start = True
        for x in args:
            if not at_start:
                file.write(sep)
            file.write(str(x))
            at_start = False
        file.write(kwargs.pop("end", "\n"))
        if kwargs.pop("flush", False):
            file.flush()
    
    
    if sys.version_info[0] < 3:
        sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
    else:
        sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
    
    input = lambda: sys.stdin.readline().rstrip("\r\n")


if __name__ == "__main__":
        main()